// 定义抽象工厂特质 `AbstractFactory`，规定了创建产品族的方法。
trait AbstractFactory {
    fn create_product_a(&self) -> Box<dyn AbstractProductA>; // 创建产品 A 的抽象方法
    fn create_product_b(&self) -> Box<dyn AbstractProductB>; // 创建产品 B 的抽象方法
}

// 定义抽象产品特质 `AbstractProductA`，规定了产品 A 的使用方法。
trait AbstractProductA {
    fn use_product_a(&self);
}

// 定义抽象产品特质 `AbstractProductB`，规定了产品 B 的使用方法。
trait AbstractProductB {
    fn use_product_b(&self);
}

// 具体工厂类型 `ConcreteFactory1` 和 `ConcreteFactory2`。
struct ConcreteFactory1;
struct ConcreteFactory2;

// 具体产品类型 `ConcreteProductA1`、`ConcreteProductA2`，实现了 `AbstractProductA` 特质。
struct ConcreteProductA1;
struct ConcreteProductA2;

// 具体产品类型 `ConcreteProductB1`、`ConcreteProductB2`，实现了 `AbstractProductB` 特质。
struct ConcreteProductB1;
struct ConcreteProductB2;

// 实现具体产品 `ConcreteProductA1` 的 `AbstractProductA` 特质。
impl AbstractProductA for ConcreteProductA1 {
    fn use_product_a(&self) {
        println!("Using ConcreteProductA1");
    }
}

// 实现具体产品 `ConcreteProductA2` 的 `AbstractProductA` 特质。
impl AbstractProductA for ConcreteProductA2 {
    fn use_product_a(&self) {
        println!("Using ConcreteProductA2");
    }
}

// 实现具体产品 `ConcreteProductB1` 的 `AbstractProductB` 特质。
impl AbstractProductB for ConcreteProductB1 {
    fn use_product_b(&self) {
        println!("Using ConcreteProductB1");
    }
}

// 实现具体产品 `ConcreteProductB2` 的 `AbstractProductB` 特质。
impl AbstractProductB for ConcreteProductB2 {
    fn use_product_b(&self) {
        println!("Using ConcreteProductB2");
    }
}

// 实现 `AbstractFactory` 特质的 `ConcreteFactory1`，为每个方法返回相应的具体产品实例。
impl AbstractFactory for ConcreteFactory1 {
    fn create_product_a(&self) -> Box<dyn AbstractProductA> {
        Box::new(ConcreteProductA1) // 返回 `ConcreteProductA1` 实例
    }

    fn create_product_b(&self) -> Box<dyn AbstractProductB> {
        Box::new(ConcreteProductB1) // 返回 `ConcreteProductB1` 实例
    }
}

// 实现 `AbstractFactory` 特质的 `ConcreteFactory2`，为每个方法返回相应的具体产品实例。
impl AbstractFactory for ConcreteFactory2 {
    fn create_product_a(&self) -> Box<dyn AbstractProductA> {
        Box::new(ConcreteProductA2) // 返回 `ConcreteProductA2` 实例
    }

    fn create_product_b(&self) -> Box<dyn AbstractProductB> {
        Box::new(ConcreteProductB2) // 返回 `ConcreteProductB2` 实例
    }
}

// 主函数入口 `main()`，演示抽象工厂模式的使用。
pub fn main() {
    // 使用 `ConcreteFactory1` 创建产品族并使用。
    let factory1 = ConcreteFactory1;
    let product_a1 = factory1.create_product_a(); // 创建产品 A1
    let product_b1 = factory1.create_product_b(); // 创建产品 B1
    product_a1.use_product_a(); // 使用产品 A1
    product_b1.use_product_b(); // 使用产品 B1

    // 使用 `ConcreteFactory2` 创建产品族并使用。
    let factory2 = ConcreteFactory2;
    let product_a2 = factory2.create_product_a(); // 创建产品 A2
    let product_b2 = factory2.create_product_b(); // 创建产品 B2
    product_a2.use_product_a(); // 使用产品 A2
    product_b2.use_product_b(); // 使用产品 B2
}
